"""
AI分析配置获取服务
负责从SystemConfig表中获取分析配置并提供给AI分析服务使用
"""
from typing import Dict, Any, Optional, List
from sqlalchemy.orm import Session
from models.system import SystemConfig
from models.analysis_task import TaskType
from core.database import get_db
from core.logging_config import get_logger
from services.ai_analysis_config_service import AIAnalysisConfigService

logger = get_logger("ai_analysis_config")


class AIAnalysisConfigProvider:
    """AI分析配置提供器"""
    
    def __init__(self):
        self.config_cache = {}
        self.cache_ttl = 300  # 5分钟缓存
    
    def get_task_config(self, task_type: str, db: Session = None) -> Dict[str, Any]:
        """
        获取指定任务类型的配置
        
        Args:
            task_type: 任务类型
            db: 数据库会话
            
        Returns:
            Dict[str, Any]: 配置数据
        """
        try:
            # 验证任务类型
            TaskType(task_type)
            
            # 检查缓存
            cache_key = f"task_config_{task_type}"
            cached_config = self._get_from_cache(cache_key)
            if cached_config:
                return cached_config
            
            # 从数据库获取配置
            if db is None:
                db = next(get_db())
            
            config_service = AIAnalysisConfigService(db)
            config_data = config_service.get_config(task_type)
            
            # 如果没有配置，获取默认配置
            if not config_data:
                config_data = config_service.get_default_config(task_type)
            
            # 缓存配置
            self._set_cache(cache_key, config_data)
            
            logger.info(f"获取任务配置成功: {task_type}")
            return config_data
            
        except Exception as e:
            logger.error(f"获取任务配置失败: {task_type}, 错误: {str(e)}")
            # 返回默认配置
            return self._get_default_task_config(task_type)
    
    def get_analysis_prompt(self, task_type: str, db: Session = None) -> str:
        """
        获取分析任务的提示词
        
        Args:
            task_type: 任务类型
            db: 数据库会话
            
        Returns:
            str: 提示词内容
        """
        config = self.get_task_config(task_type, db)
        return config.get("prompt", "")
    
    def get_regional_analysis_config(self, db: Session = None) -> Dict[str, Any]:
        """
        获取区域分析配置

        Args:
            db: 数据库会话

        Returns:
            Dict[str, Any]: 区域分析配置
        """
        config = self.get_task_config(TaskType.RegionalAnalysis.value, db)
        return {
            "analysis_levels": config.get("analysis_levels", ["地市", "区县"]),
            "region_codes": config.get("region_codes", ""),
            "enable_coordinate_analysis": config.get("enable_coordinate_analysis", False),
            "prompt": config.get("prompt", "")
        }
    
    def get_sentiment_analysis_config(self, db: Session = None) -> Dict[str, Any]:
        """
        获取情感分析配置
        
        Args:
            db: 数据库会话
            
        Returns:
            Dict[str, Any]: 情感分析配置
        """
        config = self.get_task_config(TaskType.SentimentAnalysis.value, db)
        return {
            "prompt": config.get("prompt", "")
        }
    
    def get_compliance_analysis_config(self, db: Session = None) -> Dict[str, Any]:
        """
        获取规范性分析配置
        
        Args:
            db: 数据库会话
            
        Returns:
            Dict[str, Any]: 规范性分析配置
        """
        config = self.get_task_config(TaskType.ComplianceAnalysis.value, db)
        return {
            "prompt": config.get("prompt", "")
        }
    
    def get_duplicate_analysis_config(self, db: Session = None) -> Dict[str, Any]:
        """
        获取重复信访分析配置
        
        Args:
            db: 数据库会话
            
        Returns:
            Dict[str, Any]: 重复信访分析配置
        """
        config = self.get_task_config(TaskType.DuplicateAnalysis.value, db)
        return {
            "filter_words": config.get("filter_words", ["重复", "再次", "又"]),
            "prompt": config.get("prompt", "")
        }
    
    def get_complaint_type_analysis_config(self, db: Session = None) -> Dict[str, Any]:
        """
        获取信访类型分析配置
        
        Args:
            db: 数据库会话
            
        Returns:
            Dict[str, Any]: 信访类型分析配置
        """
        config = self.get_task_config(TaskType.ComplaintTypeAnalysis.value, db)
        return {
            "prompt": config.get("prompt", "")
        }
    
    def enhance_analysis_request(self, task_type: str, request_data: Dict[str, Any], db: Session = None) -> Dict[str, Any]:
        """
        增强分析请求数据，添加配置信息
        
        Args:
            task_type: 任务类型
            request_data: 原始请求数据
            db: 数据库会话
            
        Returns:
            Dict[str, Any]: 增强后的请求数据
        """
        try:
            # 获取任务配置
            task_config = self.get_task_config(task_type, db)
            
            # 创建增强的请求数据
            enhanced_data = {
                **request_data,
                "analysis_config": {
                    "task_type": task_type,
                    "config": task_config,
                    "prompt": task_config.get("prompt", "")
                }
            }
            
            # 根据任务类型添加特定配置
            if task_type == TaskType.RegionalAnalysis.value:
                enhanced_data["analysis_config"]["analysis_levels"] = task_config.get("analysis_levels", [])
                enhanced_data["analysis_config"]["region_codes"] = task_config.get("region_codes", "")
                enhanced_data["analysis_config"]["enable_coordinate_analysis"] = task_config.get("enable_coordinate_analysis", False)
            elif task_type == TaskType.DuplicateAnalysis.value:
                enhanced_data["analysis_config"]["filter_words"] = task_config.get("filter_words", [])
            
            logger.info(f"增强分析请求数据成功: {task_type}")
            return enhanced_data
            
        except Exception as e:
            logger.error(f"增强分析请求数据失败: {task_type}, 错误: {str(e)}")
            return request_data
    
    def _get_from_cache(self, cache_key: str) -> Optional[Dict[str, Any]]:
        """从缓存获取数据"""
        import time
        cached_item = self.config_cache.get(cache_key)
        if cached_item and time.time() - cached_item["timestamp"] < self.cache_ttl:
            return cached_item["data"]
        return None
    
    def _set_cache(self, cache_key: str, data: Dict[str, Any]):
        """设置缓存数据"""
        import time
        self.config_cache[cache_key] = {
            "data": data,
            "timestamp": time.time()
        }
    
    def _get_default_task_config(self, task_type: str) -> Dict[str, Any]:
        """获取默认任务配置"""
        default_configs = {
            TaskType.RegionalAnalysis.value: {
                "analysis_levels": ["地市", "区县"],
                "region_codes": "",
                "enable_coordinate_analysis": False,
                "prompt": "请分析以下信访数据的地域分布特征，重点关注投诉热点区域和趋势变化。"
            },
            TaskType.ComplaintTypeAnalysis.value: {
                "prompt": "请对信访内容进行类型分类分析，识别主要的投诉类型和占比情况。"
            },
            TaskType.SentimentAnalysis.value: {
                "prompt": "请分析信访内容的情感倾向，包括正面、负面、中性情绪的分布和原因。"
            },
            TaskType.ComplianceAnalysis.value: {
                "prompt": "请评估信访答复的规范性，检查是否符合相关政策法规和标准格式要求。"
            },
            TaskType.DuplicateAnalysis.value: {
                "filter_words": ["重复", "再次", "又"],
                "prompt": "请识别重复或相似的信访内容，分析重复投诉的原因和模式。"
            }
        }
        
        return default_configs.get(task_type, {})
    
    def clear_cache(self):
        """清除配置缓存"""
        self.config_cache.clear()
        logger.info("配置缓存已清除")
    
    def refresh_cache(self, task_types: List[str] = None):
        """
        刷新配置缓存
        
        Args:
            task_types: 要刷新的任务类型列表，如果为None则刷新所有
        """
        try:
            if task_types is None:
                task_types = [task_type.value for task_type in TaskType]
            
            db = next(get_db())
            for task_type in task_types:
                cache_key = f"task_config_{task_type}"
                self.config_cache.pop(cache_key, None)
                # 重新加载配置
                self.get_task_config(task_type, db)
            
            logger.info(f"配置缓存刷新完成: {task_types}")
            
        except Exception as e:
            logger.error(f"刷新配置缓存失败: {str(e)}")


# 全局配置提供器实例
config_provider = AIAnalysisConfigProvider()


def get_analysis_config(task_type: str, db: Session = None) -> Dict[str, Any]:
    """
    获取分析配置的便捷函数
    
    Args:
        task_type: 任务类型
        db: 数据库会话
        
    Returns:
        Dict[str, Any]: 配置数据
    """
    return config_provider.get_task_config(task_type, db)


def enhance_analysis_request_with_config(task_type: str, request_data: Dict[str, Any], db: Session = None) -> Dict[str, Any]:
    """
    使用配置增强分析请求数据的便捷函数
    
    Args:
        task_type: 任务类型
        request_data: 原始请求数据
        db: 数据库会话
        
    Returns:
        Dict[str, Any]: 增强后的请求数据
    """
    return config_provider.enhance_analysis_request(task_type, request_data, db)